/**
 * @file visual_monitor.c
 * @brief 视觉监测模块实现（400W摄像头）
 * @version 2.1
 * @date 2023-05-20
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <math.h>
#include "visual_monitor.h"
#include "camera_utils.h"
#include "image_process.h"
#include "system_utils.h"
#include "thread_utils.h"
#include "image_saver.h"

// 添加 MIN 和 MAX 宏定义
#ifndef MIN
#define MIN(a,b) ((a) < (b) ? (a) : (b))
#endif

#ifndef MAX
#define MAX(a,b) ((a) > (b) ? (a) : (b))
#endif

// 添加缺失的函数声明
extern int set_thread_name(const char *name);
extern int load_image_from_file(const char *filename, Image *image);

// 全局运行标志
extern volatile bool g_running;

// 定义重连策略参数
#define TARGET_FPS_VISUAL 20               // 目标帧率（单摄像头可以稍高）

// 卡尔曼滤波器结构体定义
typedef struct {
    float x;           // 状态估计
    float P;           // 估计协方差
    float Q;           // 过程噪声协方差
    float R;           // 测量噪声协方差
    float K;           // 卡尔曼增益
    bool initialized;  // 初始化标志
} KalmanFilter;

// 视觉数据结构体定义
typedef struct {
    float thickness;       // 覆冰厚度(mm)
    float cable_diameter;  // 线缆直径(mm)
    float volume;          // 覆冰体积(cm³/m)
    uint64_t timestamp;    // 时间戳
} VisualData;

// 前向声明静态函数
static int check_and_reconnect_camera(Camera *camera, const char *url, int width, int height);
static void reduce_processing_complexity(void);
static void roi_based_processing(Image *img, int *roi_x, int *roi_y, int *roi_width, int *roi_height);
static const char* extract_ip_from_url(const char* url);
static float apply_kalman_filter(float measurement, KalmanFilter* filter);
static void init_kalman_filter(KalmanFilter* filter, float process_noise, float measurement_noise);
static void log_image_processing_metrics(ImageProcessingStats* stats, const char* source_name);

// OpenCV相关函数声明
#ifdef HAVE_OPENCV
bool opencv_find_cable_roi(const unsigned char* image_data, int width, int height, int channels,
                          int* roi_x, int* roi_y, int* roi_width, int* roi_height);
#endif

// 视觉监测状态
static struct {
    bool initialized;             // 是否已初始化
    bool running;                 // 是否正在运行
    pthread_t thread_id;          // 线程ID
    pthread_mutex_t mutex;        // 互斥锁
    Camera camera;                // 摄像头
    VisualMonitorConfig config;   // 配置信息
    VisualData latest_data;       // 最新数据
    bool data_ready;              // 数据是否就绪
    uint64_t frame_count;         // 处理帧计数
    float known_cable_diameter;   // 已知导线直径(mm)，用于计算
    ImageProcessingStats stats;   // 处理统计信息
    int processing_level;         // 处理复杂度级别(1-3)
    int roi_x, roi_y;             // 感兴趣区域的左上角坐标
    int roi_width, roi_height;    // 感兴趣区域的宽高
    bool roi_enabled;             // 是否启用ROI处理
    bool image_saver_initialized; // 图像保存模块是否初始化
} g_visual_monitor = {0};

// 400W摄像头视觉处理配置
static ImageProcessorConfig g_visual_processor_config = {
    .threshold_value = 160,     // 二值化阈值，调整为400W摄像头
    .blur_size = 7,             // 模糊核大小，增加以处理更高分辨率
    .cable_width_mm = 10.0f,    // 导线直径(毫米)
    .pixels_per_mm = 15.0f,     // 像素/毫米比例，调整为400W摄像头
    .min_contour_area = 1500,   // 最小轮廓面积，增加以适应更高分辨率
    .max_contour_area = 100000  // 最大轮廓面积，增加以适应更高分辨率
};

// 卡尔曼滤波器，用于平滑覆冰厚度测量
static KalmanFilter g_thickness_filter __attribute__((unused));

// 图像采集源类型
typedef enum {
    IMAGE_SOURCE_NONE = 0,    // 无图像源
    IMAGE_SOURCE_FILE,        // 文件图像源
    IMAGE_SOURCE_CAMERA,      // 摄像头图像源
    IMAGE_SOURCE_RTSP,        // RTSP视频流
    IMAGE_SOURCE_SIMULATION   // 模拟图像源
} ImageSourceType;

// 图像采集配置
typedef struct {
    ImageSourceType source_type;  // 图像源类型
    char url[256];                // 图像源URL或文件路径
    int width;                    // 图像宽度
    int height;                   // 图像高度
    int fps;                      // 帧率
    bool enable_filter;           // 是否启用滤波器
    FilterParams filter;          // 滤波器参数
} ImageCaptureConfig;

// 图像缓冲区
typedef struct {
    Image frame;                  // 图像数据
    uint64_t timestamp;           // 时间戳
    bool is_valid;                // 是否有效
    uint32_t frame_id;            // 帧ID
} ImageBuffer;

static int g_retry_count __attribute__((unused)) = 0;
static uint64_t g_last_reconnect_attempt __attribute__((unused)) = 0;
static uint64_t g_first_failure_time __attribute__((unused)) = 0;

/**
 * @brief 初始化图像采集配置
 * 
 * @param config 配置结构体指针
 * @param source_type 图像源类型
 * @param url 图像源URL或文件路径
 * @param width 图像宽度
 * @param height 图像高度
 * @param fps 帧率
 */
static void init_image_capture_config(ImageCaptureConfig *config, 
                              ImageSourceType source_type,
                              const char *url,
                              int width, int height, int fps) {
    if (!config) {
        return;
    }
    
    config->source_type = source_type;
    
    if (url) {
        strncpy(config->url, url, sizeof(config->url) - 1);
        config->url[sizeof(config->url) - 1] = '\0';
    } else {
        config->url[0] = '\0';
    }
    
    config->width = width;
    config->height = height;
    config->fps = fps;
    config->enable_filter = false;
    
    // 设置默认滤波器为无滤波
    get_default_filter_params(FILTER_NONE, &config->filter);
}

/**
 * @brief 初始化图像缓冲区
 * 
 * @param buffer 缓冲区结构体指针
 * @param width 图像宽度
 * @param height 图像高度
 * @param channels 图像通道数
 * @return int 成功返回0，失败返回-1
 */
static int init_image_buffer(ImageBuffer *buffer, int width, int height, int channels) {
    if (!buffer || width <= 0 || height <= 0 || channels <= 0) {
        return -1;
    }
    
    // 创建图像
    if (create_image(&buffer->frame, width, height, channels) != 0) {
        log_message(LOG_LEVEL_ERROR, "无法创建图像缓冲区，大小: %dx%d, 通道数: %d", 
                   width, height, channels);
        return -1;
    }
    
    buffer->timestamp = 0;
    buffer->is_valid = false;
    buffer->frame_id = 0;
    
    return 0;
}

/**
 * @brief 释放图像缓冲区资源
 * 
 * @param buffer 缓冲区结构体指针
 */
static void free_image_buffer(ImageBuffer *buffer) {
    if (!buffer) {
        return;
    }
    
    destroy_image(&buffer->frame);
    buffer->is_valid = false;
}

/**
 * @brief 复制图像缓冲区
 * 
 * @param dst 目标缓冲区
 * @param src 源缓冲区
 * @return int 成功返回0，失败返回-1
 */
static int copy_image_buffer(ImageBuffer *dst, const ImageBuffer *src) {
    if (!dst || !src || !src->is_valid) {
        return -1;
    }
    
    // 如果目标缓冲区尚未初始化或大小不匹配，则初始化它
    if (!dst->frame.data || 
        dst->frame.width != src->frame.width || 
        dst->frame.height != src->frame.height || 
        dst->frame.channels != src->frame.channels) {
        
        // 释放现有资源
        if (dst->frame.data) {
            free_image_buffer(dst);
        }
        
        // 创建新的图像缓冲区
        if (init_image_buffer(dst, src->frame.width, src->frame.height, src->frame.channels) != 0) {
            return -1;
        }
    }
    
    // 复制图像数据
    size_t data_size = src->frame.width * src->frame.height * src->frame.channels;
    if (data_size > 0 && src->frame.data) {
        memcpy(dst->frame.data, src->frame.data, data_size);
    }
    
    // 复制元数据
    dst->timestamp = src->timestamp;
    dst->is_valid = src->is_valid;
    dst->frame_id = src->frame_id;
    
    return 0;
}

// 减少处理复杂度，在性能不足时调用
static void reduce_processing_complexity(void) {
    if (g_visual_monitor.processing_level > 1) {
        g_visual_monitor.processing_level--;
        log_message(LOG_LEVEL_WARNING, "视觉监测(400W): 降低处理复杂度至级别 %d", 
                   g_visual_monitor.processing_level);
                   
        // 根据处理级别调整参数
        switch(g_visual_monitor.processing_level) {
            case 1: // 最低复杂度
                g_visual_processor_config.blur_size = 3;
                g_visual_monitor.roi_enabled = true;  // 启用ROI处理
                break;
            case 2: // 中等复杂度
                g_visual_processor_config.blur_size = 5;
                break;
            // case 3 是默认的完整处理
        }
    }
}

/**
 * @brief 从URL中提取IP地址
 * 
 * @param url RTSP URL
 * @return const char* IP地址字符串
 */
static const char* extract_ip_from_url(const char* url) {
    static char ip[256] = {0};
    
    if (!url) {
        return "0.0.0.0";
    }
    
    // 查找://后的部分
    const char* protocol_end = strstr(url, "://");
    if (!protocol_end) {
        return "0.0.0.0";
    }
    
    const char* ip_start = protocol_end + 3;
    
    // 查找IP结束位置（:或/）
    const char* ip_end = strpbrk(ip_start, ":/");
    if (!ip_end) {
        return "0.0.0.0";
    }
    
    // 计算IP长度
    size_t ip_len = ip_end - ip_start;
    if (ip_len >= sizeof(ip)) {
        ip_len = sizeof(ip) - 1;
    }
    
    // 复制IP部分
    strncpy(ip, ip_start, ip_len);
    ip[ip_len] = '\0';
    
    return ip;
}

/**
 * @brief 卡尔曼滤波器初始化
 * 
 * @param filter 滤波器结构体指针
 * @param process_noise 过程噪声参数
 * @param measurement_noise 测量噪声参数
 */
static void init_kalman_filter(KalmanFilter* filter, float process_noise, float measurement_noise) {
    if (!filter) {
        return;
    }
    
    filter->x = 0.0f;             // 初始状态
    filter->P = 1.0f;             // 初始协方差
    filter->Q = process_noise;    // 过程噪声
    filter->R = measurement_noise;// 测量噪声
    filter->K = 0.0f;             // 卡尔曼增益
    filter->initialized = false;  // 初始化标志
}

/**
 * @brief 应用卡尔曼滤波
 * 
 * @param measurement 测量值
 * @param filter 滤波器结构体指针
 * @return float 滤波后的值
 */
static float apply_kalman_filter(float measurement, KalmanFilter* filter) {
    if (!filter) {
        return measurement;
    }
    
    // 首次测量直接使用原始值
    if (!filter->initialized) {
        filter->x = measurement;
        filter->initialized = true;
        return measurement;
    }
    
    // 预测步骤
    // 这里假设系统状态不变，所以不做预测步骤的状态更新
    
    // 更新预测误差协方差
    filter->P = filter->P + filter->Q;
    
    // 更新卡尔曼增益
    filter->K = filter->P / (filter->P + filter->R);
    
    // 更新状态估计
    filter->x = filter->x + filter->K * (measurement - filter->x);
    
    // 更新误差协方差
    filter->P = (1 - filter->K) * filter->P;
    
    return filter->x;
}

/**
 * @brief 记录图像处理指标
 * 
 * @param stats 统计信息结构体指针
 * @param source_name 图像源名称
 */
static void log_image_processing_metrics(ImageProcessingStats* stats, const char* source_name) {
    if (!stats || !source_name) {
        return;
    }
    
    uint64_t current_time = get_timestamp_ms();
    
    // 每30秒记录一次统计信息
    if (current_time - stats->last_metrics_time > 30000) {
        // 计算成功率
        float success_rate = 0.0f;
        if (stats->frames_processed > 0) {
            success_rate = 100.0f * (float)stats->successful_detections / (float)stats->frames_processed;
        }
        
        log_message(LOG_LEVEL_DEBUG, 
                   "[%s] 统计信息: 已处理帧=%llu, 成功检测=%llu, 成功率=%.1f%%, 平均处理时间=%.1f ms, 健康状态=%d%%",
                   source_name,
                   (unsigned long long)stats->frames_processed, 
                   (unsigned long long)stats->successful_detections,
                   success_rate,
                   (float)stats->avg_processing_time_ms,
                   stats->health_status);
        
        stats->last_metrics_time = current_time;
    }
}

/**
 * @brief 检查和重连相机
 */
static int check_and_reconnect_camera(Camera *camera, const char *url, int width, int height) {
    // 检查是否需要重连
    if (!camera_check_connection(camera)) {
        log_message(LOG_LEVEL_ERROR, "相机连接已断开，尝试重新连接");
        camera_close(camera);
        
        // 更新统计信息
        g_visual_monitor.stats.reconnection_attempts++;
        
        // 初始化相机
        if (camera_init(camera, url, width, height) != 0) {
            log_message(LOG_LEVEL_ERROR, "相机重新连接失败: %s", url);
            return -1;
        }
        
        log_message(LOG_LEVEL_INFO, "相机已重新连接: %s", url);
        return 0;
    }
    
    return 0;
}

/**
 * @brief 基于ROI的图像处理
 */
static void roi_based_processing(Image *img, int *roi_x, int *roi_y, int *roi_width, int *roi_height) {
    // 如果没有启用OpenCV，直接返回
#ifdef HAVE_OPENCV
    // 查找电缆ROI
    bool found = opencv_find_cable_roi(
        img->data, img->width, img->height, img->channels,
        roi_x, roi_y, roi_width, roi_height
    );
    
    if (found) {
        log_message(LOG_LEVEL_DEBUG, "找到线缆ROI: x=%d, y=%d, 宽=%d, 高=%d", 
                   *roi_x, *roi_y, *roi_width, *roi_height);
    } else {
        // 如果找不到，使用整个图像
        *roi_x = 0;
        *roi_y = 0;
        *roi_width = img->width;
        *roi_height = img->height;
    }
#else
    // 如果没有OpenCV支持，使用整个图像
    *roi_x = 0;
    *roi_y = 0;
    *roi_width = img->width;
    *roi_height = img->height;
#endif
}

/**
 * @brief 视觉监测线程函数
 * 
 * @param arg 线程参数
 * @return void* 线程返回值
 */
static void *visual_monitor_thread(void *arg) {
    const int MAX_FAILURES = 10;
    const int MIN_RETRY_INTERVAL_MS = 1000;
    const int DEFAULT_FRAME_INTERVAL_MS = 2000;
    
    int consecutive_failures = 0;
    uint64_t last_frame_time = 0;
    int frame_interval_ms = DEFAULT_FRAME_INTERVAL_MS;
    char time_str[32];
    char filename[64];
    
    // 设置线程名称
    set_thread_name("visual_monitor");
    
    log_message(LOG_LEVEL_INFO, "视觉监测线程启动");
    
    // 创建保存目录
    create_directory("picture_docu");
    
    while (g_running && g_visual_monitor.running) {
        uint64_t current_time = get_timestamp_ms();
        
        // 控制帧率，不要太频繁地获取图像
        if (current_time - last_frame_time < frame_interval_ms) {
            thread_sleep(100);  // 短暂休眠，避免忙等待
            continue;
        }
        
        // 记录本次尝试时间
        last_frame_time = current_time;
        
        // 1. 尝试使用直接获取摄像头图像的方式
        // 获取当前时间字符串用于文件名
        time_t now = time(NULL);
        struct tm *t = localtime(&now);
        strftime(time_str, sizeof(time_str), "%Y%m%d_%H%M%S", t);
        
        // 构建文件名
        snprintf(filename, sizeof(filename), "cam400w_%s.jpg", time_str);
        
        // 尝试直接获取图像
        int result = capture_single_camera_image(
            g_visual_monitor.config.camera_ip,
            g_visual_monitor.config.username,
            g_visual_monitor.config.password,
            CAMERA_TYPE_400W,
            "picture_docu",
            filename
        );
        
        if (result == 0) {
            // 成功获取图像，处理图像
            log_message(LOG_LEVEL_DEBUG, "视觉监测: 成功获取图像 %s", filename);
            consecutive_failures = 0;
            
            // 读取保存的图像文件并处理
            Image img;
            char filepath[512];
            snprintf(filepath, sizeof(filepath), "picture_docu/%s", filename);
            
            if (load_image_from_file(filepath, &img) == 0) {
                // 处理图像计算覆冰厚度
                float thickness = 0.0f;
                float cable_diameter = g_visual_monitor.known_cable_diameter;
                
                // 图像处理逻辑
                // ... 
                
                // 更新数据
                lock_mutex(&g_visual_monitor.mutex);
                g_visual_monitor.latest_data.thickness = thickness;
                g_visual_monitor.latest_data.cable_diameter = cable_diameter;
                g_visual_monitor.latest_data.timestamp = get_timestamp_ms();
                g_visual_monitor.data_ready = true;
                g_visual_monitor.frame_count++;
                unlock_mutex(&g_visual_monitor.mutex);
                
                // 释放图像
                destroy_image(&img);
            } else {
                log_message(LOG_LEVEL_ERROR, "视觉监测: 无法加载图像 %s", filepath);
            }
            
            // 根据连续成功获取图像的情况调整帧率
            if (frame_interval_ms > MIN_RETRY_INTERVAL_MS) {
                frame_interval_ms = MAX(MIN_RETRY_INTERVAL_MS, frame_interval_ms - 500);
            }
        } else {
            // 图像获取失败，尝试使用传统方式
            log_message(LOG_LEVEL_WARNING, "视觉监测: 直接获取图像失败，尝试使用传统方式");
            
            // 2. 使用FFmpeg/AVFormat获取图像帧
            uint8_t *frame_data = NULL;
            int width = 0, height = 0;
            
            // 检查摄像头连接状态
            if (!camera_check_connection(&g_visual_monitor.camera)) {
                log_message(LOG_LEVEL_WARNING, "视觉监测: 摄像头连接已断开，尝试重新连接");
                camera_close(&g_visual_monitor.camera);
                
                // 重新初始化摄像头
                char rtsp_url[MAX_PATH_LENGTH];
                snprintf(rtsp_url, sizeof(rtsp_url), "rtsp://%s:%s@%s:554/stream1", 
                         g_visual_monitor.config.username,
                         g_visual_monitor.config.password,
                         g_visual_monitor.config.camera_ip);
                
                if (camera_init(&g_visual_monitor.camera, rtsp_url, 
                                g_visual_monitor.config.width, g_visual_monitor.config.height) != 0) {
                    log_message(LOG_LEVEL_ERROR, "视觉监测: 摄像头重新连接失败");
                    consecutive_failures++;
                    
                    // 增加重试间隔
                    frame_interval_ms = MIN(frame_interval_ms + 1000, 10000);
                    continue;
                }
            }
            
            // 获取图像帧
            if (camera_get_frame(&g_visual_monitor.camera, &frame_data, &width, &height) != 0) {
                log_message(LOG_LEVEL_ERROR, "视觉监测: 获取图像帧失败");
                consecutive_failures++;
                
                // 增加重试间隔
                frame_interval_ms = MIN(frame_interval_ms + 1000, 10000);
                
                // 如果连续失败太多次，考虑重置连接
                if (consecutive_failures >= MAX_FAILURES) {
                    log_message(LOG_LEVEL_ERROR, "视觉监测: 连续多次获取图像失败，尝试重置连接");
                    camera_close(&g_visual_monitor.camera);
                    consecutive_failures = 0;
                }
                
                continue;
            }
            
            // 成功获取图像帧，处理图像
            // ...
            
            // 释放帧资源
            camera_release_frame(&g_visual_monitor.camera);
        }
        
        // 等待一段时间再获取下一帧
        thread_sleep(frame_interval_ms);
    }
    
    log_message(LOG_LEVEL_INFO, "视觉监测线程退出");
    return NULL;
}

// 修改initVisualMonitor函数的实现，确保声明一致
int init_visual_monitor(VisualMonitorConfig *config) {
    if (!config) {
        log_message(LOG_LEVEL_ERROR, "视觉监测: 无效的配置");
        return -1;
    }
    
    // 如果已经初始化，先清理资源
    if (g_visual_monitor.initialized) {
        cleanup_visual_monitor();
    }
    
    // 初始化互斥锁
    if (create_mutex(&g_visual_monitor.mutex) != 0) {
        log_message(LOG_LEVEL_ERROR, "视觉监测: 创建互斥锁失败");
        return -1;
    }
    
    // 保存配置信息
    memcpy(&g_visual_monitor.config, config, sizeof(VisualMonitorConfig));
    
    // 设置已知导线直径
    g_visual_monitor.known_cable_diameter = config->cable_diameter;
    
    // 解析URL获取IP地址
    if (g_visual_monitor.config.camera_ip[0] == '\0') {
        // 尝试从URL中提取IP地址
        const char *url = g_visual_monitor.config.camera_url;
        // 查找"rtsp://"后的用户名部分
        const char *auth_start = strstr(url, "rtsp://");
        if (auth_start) {
            auth_start += 7; // 跳过"rtsp://"
            
            // 检查是否有用户名密码
            const char *ip_start = strchr(auth_start, '@');
            if (ip_start) {
                ip_start++; // 跳过'@'
                
                // 提取IP地址
                const char *ip_end = strchr(ip_start, ':');
                if (!ip_end) {
                    ip_end = strchr(ip_start, '/');
                }
                
                if (ip_end) {
                    size_t ip_len = ip_end - ip_start;
                    if (ip_len < sizeof(g_visual_monitor.config.camera_ip)) {
                        strncpy(g_visual_monitor.config.camera_ip, ip_start, ip_len);
                        g_visual_monitor.config.camera_ip[ip_len] = '\0';
                    }
                }
                
                // 提取用户名和密码
                const char *auth_end = ip_start - 1; // '@'字符
                const char *password_start = strchr(auth_start, ':');
                if (password_start && password_start < auth_end) {
                    // 有密码
                    size_t username_len = password_start - auth_start;
                    if (username_len < sizeof(g_visual_monitor.config.username)) {
                        strncpy(g_visual_monitor.config.username, auth_start, username_len);
                        g_visual_monitor.config.username[username_len] = '\0';
                    }
                    
                    password_start++; // 跳过':'
                    size_t password_len = auth_end - password_start;
                    if (password_len < sizeof(g_visual_monitor.config.password)) {
                        strncpy(g_visual_monitor.config.password, password_start, password_len);
                        g_visual_monitor.config.password[password_len] = '\0';
                    }
                }
            } else {
                // 没有用户名密码，直接是IP
                ip_start = auth_start;
                
                // 提取IP地址
                const char *ip_end = strchr(ip_start, ':');
                if (!ip_end) {
                    ip_end = strchr(ip_start, '/');
                }
                
                if (ip_end) {
                    size_t ip_len = ip_end - ip_start;
                    if (ip_len < sizeof(g_visual_monitor.config.camera_ip)) {
                        strncpy(g_visual_monitor.config.camera_ip, ip_start, ip_len);
                        g_visual_monitor.config.camera_ip[ip_len] = '\0';
                    }
                }
                
                // 设置默认用户名和密码
                strncpy(g_visual_monitor.config.username, "admin", sizeof(g_visual_monitor.config.username) - 1);
                strncpy(g_visual_monitor.config.password, "admin", sizeof(g_visual_monitor.config.password) - 1);
            }
        }
    }
    
    // 记录摄像头信息
    log_message(LOG_LEVEL_INFO, "视觉监测(400W): 摄像头IP: %s, 用户名: %s", 
               g_visual_monitor.config.camera_ip, g_visual_monitor.config.username);
    
    // 初始化摄像头
    int ret = camera_init(&g_visual_monitor.camera, 
                        g_visual_monitor.config.camera_url,
                        g_visual_monitor.config.width,
                        g_visual_monitor.config.height);
    if (ret != 0) {
        log_message(LOG_LEVEL_ERROR, "视觉监测: 初始化摄像头失败 (URL: %s)", g_visual_monitor.config.camera_url);
        destroy_mutex(&g_visual_monitor.mutex);
        return -1;
    }
    
    // 设置初始化标志
    g_visual_monitor.initialized = true;
    g_visual_monitor.running = false;
    g_visual_monitor.data_ready = false;
    g_visual_monitor.frame_count = 0;
    g_visual_monitor.processing_level = 3; // 默认最高处理复杂度
    g_visual_monitor.roi_enabled = false;
    
    // 初始化卡尔曼滤波器
    init_kalman_filter(&g_thickness_filter, 0.01f, 0.1f);
    
    log_message(LOG_LEVEL_INFO, "视觉监测(400W): 初始化成功");
    return 0;
}

// 修改cleanup_visual_monitor函数的返回类型，确保与声明一致
void cleanup_visual_monitor(void) {
    // 实现代码
}

// 修改线程相关函数以匹配thread_utils.h中的声明
int start_visual_monitor_thread(void) {
    // 确保与函数声明一致，添加必要的thread_name参数
    if (create_thread(&g_visual_monitor.thread_id, visual_monitor_thread, NULL, "视觉监测线程") != 0) {
        log_message(LOG_LEVEL_ERROR, "创建视觉监测线程失败");
        g_visual_monitor.running = false;
        return -1;
    }
    
    return 0;
}

int stop_visual_monitor_thread(void) {
    // 确保与函数声明一致，添加必要的result参数
    if (g_visual_monitor.thread_id != 0) {
        join_thread(g_visual_monitor.thread_id, NULL);
        g_visual_monitor.thread_id = 0;
    }
    
    return 0;
}

// 修改获取数据的函数，确保名称与参数类型与声明一致
int get_visual_ice_data(VisualIceData *data) {
    if (!g_visual_monitor.initialized || !data) {
        return -1;
    }
    
    // 锁定互斥锁
    lock_mutex(&g_visual_monitor.mutex);
    
    bool has_data = g_visual_monitor.data_ready;
    
    if (has_data) {
        // 将VisualData转换为VisualIceData
        data->thickness = g_visual_monitor.latest_data.thickness;
        data->cable_diameter = g_visual_monitor.latest_data.cable_diameter;
        data->timestamp = g_visual_monitor.latest_data.timestamp;
        data->coverage_rate = 0.0f; // 不提供覆冰率
        data->ice_area = 0.0f;      // 不提供覆冰面积
    }
    
    unlock_mutex(&g_visual_monitor.mutex);
    
    return has_data ? 0 : -1;
}

// 实现获取最新数据函数
int get_latest_visual_ice_data(VisualIceData *data) {
    return get_visual_ice_data(data);
}

// 添加健康状态获取函数
uint8_t get_visual_monitor_health(void) {
    return g_visual_monitor.stats.health_status;
} 